/**
 * 工作台store
 */
import { makeAutoObservable } from "mobx";

import {
  fetchAddWorkbench,
  fetchAllWorkbench,
  fetchDelWorkbench,
  fetchUpdateWorkbench,
  fetchWorkbenchDetail,
  fetchExpTableList,
  fetchAddExpTable,
  fetchUpdateExpTable,
  fetchDelExpTable,
  // fetchExpTableDetail,
} from "../api/workbench";

import { ITResponseData, checkResonse } from "../api";

import {
  ITWorkbench,
  ITWorkbenchSlot,
  ITBadResp,
  ITExpTable,
} from "./interfaces";

export interface ITWorkbenchStore {
  // 显示新增编辑工作台弹窗
  showAddEditWorkBenchModal: boolean;

  // 修改
  changeShowAddEditWorkBenchModal: (data: boolean) => void;

  // 新增工作台loading
  addWorkbenchLoading: boolean;

  // 修改新增工作台loading
  changeAddWorkbenchLoading: (data: boolean) => void;

  // 新增工作台请求
  addWorkbench: (data: any) => Promise<ITBadResp | null>;

  // 当前正在编辑的工作台数据
  editWorkbenchData: ITWorkbench;

  // 修改当前工作台示例数据
  changeEditWorkbenchData: (data: any) => void;

  // 清除当前工作台示例数据
  clearEditWorkbenchData: () => void;

  // 修改工作台请求
  updateWorkbench: (data: any) => Promise<ITBadResp | null>;

  // 工作台插槽列表
  workbenchSlotlist: ITWorkbenchSlot[];

  // 修改工作台插槽列表
  changeWorkbenchSlotlist: (data: ITWorkbenchSlot[]) => void;

  // 所有工作台
  allWorkbench: ITWorkbench[];

  // 修改所有工作台
  changeAllWorkbench: (data: ITWorkbench[]) => void;

  // 获取所有工作台请求状态
  allWorkbenchLoading: boolean;

  // 修改获取所有工作台请求状态
  changeAllWorkbenchLoading: (data: boolean) => void;

  // 获取所有试管架
  getAllWorkbench: () => Promise<ITBadResp | void>;

  // 删除工作台请求状态
  delWorkbenchLoading: boolean;

  // 修改删除工作台请求状态
  changeDelWorkbenchLoading: (data: boolean) => void;

  // 删除工作台请求
  delWorkbench: (data: any) => Promise<ITBadResp | null>;

  // 根据id请求工作台信息
  getWorkbenchById: (data: any) => Promise<ITBadResp | ITWorkbench>;

  // 所有预设实验台
  allExpTable: ITExpTable[];

  // 修改所有预设试验台
  changeAllExpTable: (data: ITExpTable[]) => void;

  // 请求预设工作台列表loading
  expTableListLoading: boolean;

  // 修改请求预设工作台列表loading
  changeExpTableListLoading: (data: boolean) => void;

  // 请求所有预设试验台
  getAllExpTable: () => Promise<ITBadResp | null>;

  // 新增预设试验桌
  addExpTable: (data: any) => Promise<ITBadResp | null>;

  // 修改预设实验桌
  upDateExpTable: (data: any) => Promise<ITBadResp | null>;

  // 删除预设实验桌
  delExpTable: (data: any) => Promise<ITBadResp | null>;

  // 请求预设工作台详细信息
  // getExpTableInfo: (data: any) => Promise<ITBadResp | ITExpTable>;
}

class WorkbenchStore {
  constructor() {
    makeAutoObservable(this, {}, { autoBind: true });
  }

  // 显示新增编辑工作台弹窗
  showAddEditWorkBenchModal = false;

  // 修改
  changeShowAddEditWorkBenchModal = (data: boolean) =>
    (this.showAddEditWorkBenchModal = data);

  // 新增工作台loading
  addWorkbenchLoading = false;

  // 修改新增工作台loading
  changeAddWorkbenchLoading = (data: boolean) =>
    (this.addWorkbenchLoading = data);

  // 新增工作台请求
  addWorkbench = async (data: any): Promise<ITBadResp | null> => {
    this.changeAddWorkbenchLoading(true);
    const res = await fetchAddWorkbench(data);
    this.changeAddWorkbenchLoading(false);
    if (checkResonse(res)) {
      return null;
    }
    const { message } = res.data;
    return {
      msg: message,
    };
  };

  // 当前正在编辑的工作台数据
  editWorkbenchData = {};

  // 修改当前试管架示例数据
  changeEditWorkbenchData = (data: any) => {
    this.editWorkbenchData = {
      ...this.editWorkbenchData,
      ...data,
    };
  };

  // 清除当前示例数据
  clearEditWorkbenchData = () => {
    this.editWorkbenchData = {};
  };

  // 修改工作台请求
  updateWorkbench = async (data: any): Promise<ITBadResp | null> => {
    this.changeAddWorkbenchLoading(true);
    const res = await fetchUpdateWorkbench(data);
    this.changeAddWorkbenchLoading(false);
    if (checkResonse(res)) {
      return null;
    }
    const { message } = res.data;
    return {
      msg: message,
    };
  };

  // 工作台插槽列表
  workbenchSlotlist: ITWorkbenchSlot[] = [];

  // 修改工作台插槽列表
  changeWorkbenchSlotlist = (data: ITWorkbenchSlot[]) =>
    (this.workbenchSlotlist = data);

  // 所有工作台
  allWorkbench: ITWorkbench[] = [];

  // 修改所有工作台
  changeAllWorkbench = (data: ITWorkbench[]) => {
    this.allWorkbench = data;
  };

  // 获取所有工作台请求状态
  allWorkbenchLoading = false;

  // 修改获取所有工作台请求状态
  changeAllWorkbenchLoading = (data: boolean) => {
    this.allWorkbenchLoading = data;
  };

  // 获取所有工作台
  getAllWorkbench = async (): Promise<ITBadResp | void> => {
    this.changeAllWorkbenchLoading(true);
    const res = await fetchAllWorkbench();
    this.changeAllWorkbenchLoading(false);
    if (checkResonse(res)) {
      const result: ITResponseData = res.data;
      const { data } = result;
      data.forEach((item: ITWorkbench, index: number) => (item.key = index));
      this.changeAllWorkbench(data);
    }
  };

  // 删除工作台请求状态
  delWorkbenchLoading = false;

  // 修改删除工作台请求状态
  changeDelWorkbenchLoading = (data: boolean) =>
    (this.delWorkbenchLoading = data);

  // 删除工作台请求
  delWorkbench = async (data: any): Promise<ITBadResp | null> => {
    this.changeDelWorkbenchLoading(true);
    const res = await fetchDelWorkbench(data);
    this.changeDelWorkbenchLoading(false);
    if (checkResonse(res)) {
      return null;
    }
    const { message } = res.data;
    return {
      msg: message,
    };
  };

  // 根据id请求工作台信息
  getWorkbenchById = async (data: any): Promise<ITBadResp | ITWorkbench> => {
    const res = await fetchWorkbenchDetail(data);
    if (checkResonse(res)) {
      const { data } = res.data;
      return data;
    }
    const { message } = res.data;
    return {
      msg: message,
    };
  };

  // 所有预设实验台
  allExpTable: ITExpTable[] = [];

  // 修改所有预设试验台
  changeAllExpTable = (data: ITExpTable[]) => {
    this.allExpTable = data;
  };

  // 请求预设工作台列表loading
  expTableListLoading: boolean = false;

  // 修改请求预设工作台列表loading
  changeExpTableListLoading = (data: boolean): void => {
    this.expTableListLoading = data;
  };

  // 请求所有预设试验台
  getAllExpTable = async (): Promise<ITBadResp | null> => {
    this.changeExpTableListLoading(true);
    const res = await fetchExpTableList();
    this.changeExpTableListLoading(false);
    if (checkResonse(res)) {
      const result: ITResponseData = res.data;
      const { data } = result;
      data.forEach((item: ITExpTable, index: number) => (item.key = index));
      this.changeAllExpTable(data);
    }

    return null;
  };

  // 新增预设试验桌
  addExpTable = async (data: any): Promise<ITBadResp | null> => {
    const res = await fetchAddExpTable(data);
    if (checkResonse(res)) {
      return null;
    }
    const { message } = res.data;
    return {
      msg: message,
    };
  };

  // 修改预设实验桌
  upDateExpTable = async (data: any): Promise<ITBadResp | null> => {
    const res = await fetchUpdateExpTable(data);
    if (checkResonse(res)) {
      return null;
    }
    const { message } = res.data;
    return {
      msg: message,
    };
  };

  // 删除预设实验桌
  delExpTable = async (data: any): Promise<ITBadResp | null> => {
    const res = await fetchDelExpTable(data);
    if (checkResonse(res)) {
      return null;
    }
    const { message } = res.data;
    return {
      msg: message,
    };
  };

  // 请求预设工作台详细信息
  // getExpTableInfo = async (data: any): Promise<ITBadResp | ITExpTable> => {
  //   const res = await fetchExpTableDetail(data);
  //   if (checkResonse(res)) {
  //     return res.data;
  //   }
  //   const { message } = res.data;
  //   return {
  //     msg: message,
  //   };
  // };
}

const workbenchStore: ITWorkbenchStore = new WorkbenchStore();
export default workbenchStore;
